home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 March / PCWMAR09.iso / Software / Freeware / Adobe Media Player 1.6 / adobe_media_player.air / AMP.swf / scripts / mx / managers / ToolTipManagerImpl.as < prev    next >
Encoding:
Text File  |  2008-11-25  |  24.7 KB  |  753 lines
  1. package mx.managers
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.events.Event;
  5.    import flash.events.EventDispatcher;
  6.    import flash.events.IEventDispatcher;
  7.    import flash.events.MouseEvent;
  8.    import flash.events.TimerEvent;
  9.    import flash.geom.Point;
  10.    import flash.geom.Rectangle;
  11.    import flash.utils.Timer;
  12.    import mx.controls.ToolTip;
  13.    import mx.core.ApplicationGlobals;
  14.    import mx.core.IInvalidating;
  15.    import mx.core.IToolTip;
  16.    import mx.core.IUIComponent;
  17.    import mx.core.mx_internal;
  18.    import mx.effects.EffectManager;
  19.    import mx.effects.IAbstractEffect;
  20.    import mx.events.EffectEvent;
  21.    import mx.events.InterManagerRequest;
  22.    import mx.events.ToolTipEvent;
  23.    import mx.styles.IStyleClient;
  24.    import mx.validators.IValidatorListener;
  25.    
  26.    use namespace mx_internal;
  27.    
  28.    public class ToolTipManagerImpl extends EventDispatcher implements IToolTipManager2
  29.    {
  30.       private static var instance:IToolTipManager2;
  31.       
  32.       mx_internal static const VERSION:String = "3.2.0.3958";
  33.       
  34.       private var _enabled:Boolean = true;
  35.       
  36.       private var _showDelay:Number = 500;
  37.       
  38.       private var _hideEffect:IAbstractEffect;
  39.       
  40.       mx_internal var hideTimer:Timer;
  41.       
  42.       private var _scrubDelay:Number = 100;
  43.       
  44.       private var _toolTipClass:Class;
  45.       
  46.       mx_internal var showTimer:Timer;
  47.       
  48.       private var sandboxRoot:IEventDispatcher = null;
  49.       
  50.       mx_internal var currentText:String;
  51.       
  52.       private var _currentToolTip:DisplayObject;
  53.       
  54.       mx_internal var scrubTimer:Timer;
  55.       
  56.       mx_internal var previousTarget:DisplayObject;
  57.       
  58.       private var _currentTarget:DisplayObject;
  59.       
  60.       private var systemManager:ISystemManager = null;
  61.       
  62.       private var _showEffect:IAbstractEffect;
  63.       
  64.       private var _hideDelay:Number = 10000;
  65.       
  66.       mx_internal var initialized:Boolean = false;
  67.       
  68.       mx_internal var isError:Boolean;
  69.       
  70.       public function ToolTipManagerImpl()
  71.       {
  72.          _toolTipClass = ToolTip;
  73.          super();
  74.          if(instance)
  75.          {
  76.             throw new Error("Instance already exists.");
  77.          }
  78.          this.systemManager = SystemManagerGlobals.topLevelSystemManagers[0] as ISystemManager;
  79.          sandboxRoot = this.systemManager.getSandboxRoot();
  80.          sandboxRoot.addEventListener(InterManagerRequest.TOOLTIP_MANAGER_REQUEST,marshalToolTipManagerHandler,false,0,true);
  81.          var _loc1_:InterManagerRequest = new InterManagerRequest(InterManagerRequest.TOOLTIP_MANAGER_REQUEST);
  82.          _loc1_.name = "update";
  83.          sandboxRoot.dispatchEvent(_loc1_);
  84.       }
  85.       
  86.       public static function getInstance() : IToolTipManager2
  87.       {
  88.          if(!instance)
  89.          {
  90.             instance = new ToolTipManagerImpl();
  91.          }
  92.          return instance;
  93.       }
  94.       
  95.       mx_internal function systemManager_mouseDownHandler(param1:MouseEvent) : void
  96.       {
  97.          mx_internal::reset();
  98.       }
  99.       
  100.       public function set showDelay(param1:Number) : void
  101.       {
  102.          _showDelay = param1;
  103.       }
  104.       
  105.       mx_internal function showTimer_timerHandler(param1:TimerEvent) : void
  106.       {
  107.          if(currentTarget)
  108.          {
  109.             mx_internal::createTip();
  110.             mx_internal::initializeTip();
  111.             mx_internal::positionTip();
  112.             mx_internal::showTip();
  113.          }
  114.       }
  115.       
  116.       mx_internal function hideEffectEnded() : void
  117.       {
  118.          var _loc1_:ToolTipEvent = null;
  119.          mx_internal::reset();
  120.          if(mx_internal::previousTarget)
  121.          {
  122.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_END);
  123.             _loc1_.toolTip = currentToolTip;
  124.             mx_internal::previousTarget.dispatchEvent(_loc1_);
  125.          }
  126.       }
  127.       
  128.       public function set scrubDelay(param1:Number) : void
  129.       {
  130.          _scrubDelay = param1;
  131.       }
  132.       
  133.       public function get currentToolTip() : IToolTip
  134.       {
  135.          return _currentToolTip as IToolTip;
  136.       }
  137.       
  138.       private function mouseIsOver(param1:DisplayObject) : Boolean
  139.       {
  140.          if(!param1 || !param1.stage)
  141.          {
  142.             return false;
  143.          }
  144.          if(param1.stage.mouseX == 0 && param1.stage.mouseY == 0)
  145.          {
  146.             return false;
  147.          }
  148.          return param1.hitTestPoint(param1.stage.mouseX,param1.stage.mouseY,true);
  149.       }
  150.       
  151.       mx_internal function toolTipMouseOutHandler(param1:MouseEvent) : void
  152.       {
  153.          mx_internal::checkIfTargetChanged(param1.relatedObject);
  154.       }
  155.       
  156.       public function get enabled() : Boolean
  157.       {
  158.          return _enabled;
  159.       }
  160.       
  161.       public function createToolTip(param1:String, param2:Number, param3:Number, param4:String = null, param5:IUIComponent = null) : IToolTip
  162.       {
  163.          var _loc6_:ToolTip = new ToolTip();
  164.          var _loc7_:ISystemManager = !!param5 ? param5.systemManager as ISystemManager : ApplicationGlobals.application.systemManager as ISystemManager;
  165.          _loc7_.topLevelSystemManager.addChildToSandboxRoot("toolTipChildren",_loc6_ as DisplayObject);
  166.          if(param4)
  167.          {
  168.             _loc6_.setStyle("styleName","errorTip");
  169.             _loc6_.setStyle("borderStyle",param4);
  170.          }
  171.          _loc6_.text = param1;
  172.          sizeTip(_loc6_);
  173.          _loc6_.move(param2,param3);
  174.          return _loc6_ as IToolTip;
  175.       }
  176.       
  177.       mx_internal function reset() : void
  178.       {
  179.          var _loc1_:ISystemManager = null;
  180.          mx_internal::showTimer.reset();
  181.          mx_internal::hideTimer.reset();
  182.          if(currentToolTip)
  183.          {
  184.             if(Boolean(showEffect) || Boolean(hideEffect))
  185.             {
  186.                currentToolTip.removeEventListener(EffectEvent.EFFECT_END,mx_internal::effectEndHandler);
  187.             }
  188.             EffectManager.endEffectsForTarget(currentToolTip);
  189.             _loc1_ = currentToolTip.systemManager as ISystemManager;
  190.             _loc1_.topLevelSystemManager.removeChildFromSandboxRoot("toolTipChildren",currentToolTip as DisplayObject);
  191.             currentToolTip = null;
  192.             mx_internal::scrubTimer.delay = scrubDelay;
  193.             mx_internal::scrubTimer.reset();
  194.             if(scrubDelay > 0)
  195.             {
  196.                mx_internal::scrubTimer.delay = scrubDelay;
  197.                mx_internal::scrubTimer.start();
  198.             }
  199.          }
  200.       }
  201.       
  202.       public function set currentToolTip(param1:IToolTip) : void
  203.       {
  204.          _currentToolTip = param1 as DisplayObject;
  205.          var _loc2_:InterManagerRequest = new InterManagerRequest(InterManagerRequest.TOOLTIP_MANAGER_REQUEST);
  206.          _loc2_.name = "currentToolTip";
  207.          _loc2_.value = param1;
  208.          sandboxRoot.dispatchEvent(_loc2_);
  209.       }
  210.       
  211.       public function get toolTipClass() : Class
  212.       {
  213.          return _toolTipClass;
  214.       }
  215.       
  216.       private function hideImmediately(param1:DisplayObject) : void
  217.       {
  218.          mx_internal::checkIfTargetChanged(null);
  219.       }
  220.       
  221.       mx_internal function showTip() : void
  222.       {
  223.          var _loc2_:ISystemManager = null;
  224.          var _loc1_:ToolTipEvent = new ToolTipEvent(ToolTipEvent.TOOL_TIP_SHOW);
  225.          _loc1_.toolTip = currentToolTip;
  226.          currentTarget.dispatchEvent(_loc1_);
  227.          if(mx_internal::isError)
  228.          {
  229.             currentTarget.addEventListener("change",mx_internal::changeHandler);
  230.          }
  231.          else
  232.          {
  233.             _loc2_ = getSystemManager(currentTarget);
  234.             _loc2_.addEventListener(MouseEvent.MOUSE_DOWN,mx_internal::systemManager_mouseDownHandler);
  235.          }
  236.          currentToolTip.visible = true;
  237.          if(!showEffect)
  238.          {
  239.             mx_internal::showEffectEnded();
  240.          }
  241.       }
  242.       
  243.       mx_internal function effectEndHandler(param1:EffectEvent) : void
  244.       {
  245.          if(param1.effectInstance.effect == showEffect)
  246.          {
  247.             mx_internal::showEffectEnded();
  248.          }
  249.          else if(param1.effectInstance.effect == hideEffect)
  250.          {
  251.             mx_internal::hideEffectEnded();
  252.          }
  253.       }
  254.       
  255.       public function get hideDelay() : Number
  256.       {
  257.          return _hideDelay;
  258.       }
  259.       
  260.       public function get currentTarget() : DisplayObject
  261.       {
  262.          return _currentTarget;
  263.       }
  264.       
  265.       mx_internal function showEffectEnded() : void
  266.       {
  267.          var _loc1_:ToolTipEvent = null;
  268.          if(hideDelay == 0)
  269.          {
  270.             mx_internal::hideTip();
  271.          }
  272.          else if(hideDelay < Infinity)
  273.          {
  274.             mx_internal::hideTimer.delay = hideDelay;
  275.             mx_internal::hideTimer.start();
  276.          }
  277.          if(currentTarget)
  278.          {
  279.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_SHOWN);
  280.             _loc1_.toolTip = currentToolTip;
  281.             currentTarget.dispatchEvent(_loc1_);
  282.          }
  283.       }
  284.       
  285.       public function get hideEffect() : IAbstractEffect
  286.       {
  287.          return _hideEffect;
  288.       }
  289.       
  290.       mx_internal function changeHandler(param1:Event) : void
  291.       {
  292.          mx_internal::reset();
  293.       }
  294.       
  295.       public function set enabled(param1:Boolean) : void
  296.       {
  297.          _enabled = param1;
  298.       }
  299.       
  300.       mx_internal function errorTipMouseOverHandler(param1:MouseEvent) : void
  301.       {
  302.          mx_internal::checkIfTargetChanged(DisplayObject(param1.target));
  303.       }
  304.       
  305.       public function get showDelay() : Number
  306.       {
  307.          return _showDelay;
  308.       }
  309.       
  310.       public function get scrubDelay() : Number
  311.       {
  312.          return _scrubDelay;
  313.       }
  314.       
  315.       public function registerErrorString(param1:DisplayObject, param2:String, param3:String) : void
  316.       {
  317.          if(!param2 && Boolean(param3))
  318.          {
  319.             param1.addEventListener(MouseEvent.MOUSE_OVER,mx_internal::errorTipMouseOverHandler);
  320.             param1.addEventListener(MouseEvent.MOUSE_OUT,mx_internal::errorTipMouseOutHandler);
  321.             if(mouseIsOver(param1))
  322.             {
  323.                showImmediately(param1);
  324.             }
  325.          }
  326.          else if(Boolean(param2) && !param3)
  327.          {
  328.             param1.removeEventListener(MouseEvent.MOUSE_OVER,mx_internal::errorTipMouseOverHandler);
  329.             param1.removeEventListener(MouseEvent.MOUSE_OUT,mx_internal::errorTipMouseOutHandler);
  330.             if(mouseIsOver(param1))
  331.             {
  332.                hideImmediately(param1);
  333.             }
  334.          }
  335.       }
  336.       
  337.       mx_internal function initialize() : void
  338.       {
  339.          if(!mx_internal::showTimer)
  340.          {
  341.             mx_internal::showTimer = new Timer(0,1);
  342.             mx_internal::showTimer.addEventListener(TimerEvent.TIMER,mx_internal::showTimer_timerHandler);
  343.          }
  344.          if(!mx_internal::hideTimer)
  345.          {
  346.             mx_internal::hideTimer = new Timer(0,1);
  347.             mx_internal::hideTimer.addEventListener(TimerEvent.TIMER,mx_internal::hideTimer_timerHandler);
  348.          }
  349.          if(!mx_internal::scrubTimer)
  350.          {
  351.             mx_internal::scrubTimer = new Timer(0,1);
  352.          }
  353.          mx_internal::initialized = true;
  354.       }
  355.       
  356.       public function destroyToolTip(param1:IToolTip) : void
  357.       {
  358.          var _loc2_:ISystemManager = param1.systemManager as ISystemManager;
  359.          _loc2_.topLevelSystemManager.removeChildFromSandboxRoot("toolTipChildren",DisplayObject(param1));
  360.       }
  361.       
  362.       mx_internal function checkIfTargetChanged(param1:DisplayObject) : void
  363.       {
  364.          if(!enabled)
  365.          {
  366.             return;
  367.          }
  368.          mx_internal::findTarget(param1);
  369.          if(currentTarget != mx_internal::previousTarget)
  370.          {
  371.             mx_internal::targetChanged();
  372.             mx_internal::previousTarget = currentTarget;
  373.          }
  374.       }
  375.       
  376.       private function marshalToolTipManagerHandler(param1:Event) : void
  377.       {
  378.          var _loc2_:InterManagerRequest = null;
  379.          if(param1 is InterManagerRequest)
  380.          {
  381.             return;
  382.          }
  383.          var _loc3_:Object = param1;
  384.          switch(_loc3_.name)
  385.          {
  386.             case "currentToolTip":
  387.                _currentToolTip = _loc3_.value;
  388.                break;
  389.             case ToolTipEvent.TOOL_TIP_HIDE:
  390.                if(_currentToolTip is IToolTip)
  391.                {
  392.                   mx_internal::hideTip();
  393.                }
  394.                break;
  395.             case "update":
  396.                param1.stopImmediatePropagation();
  397.                _loc2_ = new InterManagerRequest(InterManagerRequest.TOOLTIP_MANAGER_REQUEST);
  398.                _loc2_.name = "currentToolTip";
  399.                _loc2_.value = _currentToolTip;
  400.                sandboxRoot.dispatchEvent(_loc2_);
  401.          }
  402.       }
  403.       
  404.       public function set toolTipClass(param1:Class) : void
  405.       {
  406.          _toolTipClass = param1;
  407.       }
  408.       
  409.       private function getGlobalBounds(param1:DisplayObject, param2:DisplayObject) : Rectangle
  410.       {
  411.          var _loc3_:Point = new Point(0,0);
  412.          _loc3_ = param1.localToGlobal(_loc3_);
  413.          _loc3_ = param2.globalToLocal(_loc3_);
  414.          return new Rectangle(_loc3_.x,_loc3_.y,param1.width,param1.height);
  415.       }
  416.       
  417.       mx_internal function positionTip() : void
  418.       {
  419.          var _loc1_:Number = NaN;
  420.          var _loc2_:Number = NaN;
  421.          var _loc5_:Rectangle = null;
  422.          var _loc6_:Point = null;
  423.          var _loc7_:IToolTip = null;
  424.          var _loc8_:Number = NaN;
  425.          var _loc9_:Number = NaN;
  426.          var _loc10_:ISystemManager = null;
  427.          var _loc11_:Number = NaN;
  428.          var _loc12_:Number = NaN;
  429.          var _loc3_:Number = currentToolTip.screen.width;
  430.          var _loc4_:Number = currentToolTip.screen.height;
  431.          if(mx_internal::isError)
  432.          {
  433.             _loc5_ = getGlobalBounds(currentTarget,currentToolTip.root);
  434.             _loc1_ = _loc5_.right + 4;
  435.             _loc2_ = _loc5_.top - 1;
  436.             if(_loc1_ + currentToolTip.width > _loc3_)
  437.             {
  438.                _loc8_ = NaN;
  439.                _loc9_ = NaN;
  440.                _loc1_ = _loc5_.left - 2;
  441.                if(_loc1_ + currentToolTip.width + 4 > _loc3_)
  442.                {
  443.                   _loc8_ = _loc3_ - _loc1_ - 4;
  444.                   _loc9_ = Number(Object(toolTipClass).maxWidth);
  445.                   Object(toolTipClass).maxWidth = _loc8_;
  446.                   if(currentToolTip is IStyleClient)
  447.                   {
  448.                      IStyleClient(currentToolTip).setStyle("borderStyle","errorTipAbove");
  449.                   }
  450.                   currentToolTip["text"] = currentToolTip["text"];
  451.                   Object(toolTipClass).maxWidth = _loc9_;
  452.                }
  453.                else
  454.                {
  455.                   if(currentToolTip is IStyleClient)
  456.                   {
  457.                      IStyleClient(currentToolTip).setStyle("borderStyle","errorTipAbove");
  458.                   }
  459.                   currentToolTip["text"] = currentToolTip["text"];
  460.                }
  461.                if(currentToolTip.height + 2 < _loc5_.top)
  462.                {
  463.                   _loc2_ = _loc5_.top - (currentToolTip.height + 2);
  464.                }
  465.                else
  466.                {
  467.                   _loc2_ = _loc5_.bottom + 2;
  468.                   if(!isNaN(_loc8_))
  469.                   {
  470.                      Object(toolTipClass).maxWidth = _loc8_;
  471.                   }
  472.                   if(currentToolTip is IStyleClient)
  473.                   {
  474.                      IStyleClient(currentToolTip).setStyle("borderStyle","errorTipBelow");
  475.                   }
  476.                   currentToolTip["text"] = currentToolTip["text"];
  477.                   if(!isNaN(_loc9_))
  478.                   {
  479.                      Object(toolTipClass).maxWidth = _loc9_;
  480.                   }
  481.                }
  482.             }
  483.             sizeTip(currentToolTip);
  484.             _loc6_ = new Point(_loc1_,_loc2_);
  485.             _loc7_ = currentToolTip;
  486.             _loc1_ = _loc6_.x;
  487.             _loc2_ = _loc6_.y;
  488.          }
  489.          else
  490.          {
  491.             _loc10_ = getSystemManager(currentTarget);
  492.             _loc1_ = DisplayObject(_loc10_).mouseX + 11;
  493.             _loc2_ = DisplayObject(_loc10_).mouseY + 22;
  494.             _loc11_ = Number(currentToolTip.width);
  495.             if(_loc1_ + _loc11_ > _loc3_)
  496.             {
  497.                _loc1_ = _loc3_ - _loc11_;
  498.             }
  499.             _loc12_ = Number(currentToolTip.height);
  500.             if(_loc2_ + _loc12_ > _loc4_)
  501.             {
  502.                _loc2_ = _loc4_ - _loc12_;
  503.             }
  504.             _loc6_ = new Point(_loc1_,_loc2_);
  505.             _loc6_ = DisplayObject(_loc10_).localToGlobal(_loc6_);
  506.             _loc6_ = DisplayObject(sandboxRoot).globalToLocal(_loc6_);
  507.             _loc1_ = _loc6_.x;
  508.             _loc2_ = _loc6_.y;
  509.          }
  510.          currentToolTip.move(_loc1_,_loc2_);
  511.       }
  512.       
  513.       mx_internal function errorTipMouseOutHandler(param1:MouseEvent) : void
  514.       {
  515.          mx_internal::checkIfTargetChanged(param1.relatedObject);
  516.       }
  517.       
  518.       mx_internal function findTarget(param1:DisplayObject) : void
  519.       {
  520.          while(param1)
  521.          {
  522.             if(param1 is IValidatorListener)
  523.             {
  524.                mx_internal::currentText = IValidatorListener(param1).errorString;
  525.                if(mx_internal::currentText != null && mx_internal::currentText != "")
  526.                {
  527.                   currentTarget = param1;
  528.                   mx_internal::isError = true;
  529.                   return;
  530.                }
  531.             }
  532.             if(param1 is IToolTipManagerClient)
  533.             {
  534.                mx_internal::currentText = IToolTipManagerClient(param1).toolTip;
  535.                if(mx_internal::currentText != null)
  536.                {
  537.                   currentTarget = param1;
  538.                   mx_internal::isError = false;
  539.                   return;
  540.                }
  541.             }
  542.             param1 = param1.parent;
  543.          }
  544.          mx_internal::currentText = null;
  545.          currentTarget = null;
  546.       }
  547.       
  548.       public function registerToolTip(param1:DisplayObject, param2:String, param3:String) : void
  549.       {
  550.          if(!param2 && Boolean(param3))
  551.          {
  552.             param1.addEventListener(MouseEvent.MOUSE_OVER,mx_internal::toolTipMouseOverHandler);
  553.             param1.addEventListener(MouseEvent.MOUSE_OUT,mx_internal::toolTipMouseOutHandler);
  554.             if(mouseIsOver(param1))
  555.             {
  556.                showImmediately(param1);
  557.             }
  558.          }
  559.          else if(Boolean(param2) && !param3)
  560.          {
  561.             param1.removeEventListener(MouseEvent.MOUSE_OVER,mx_internal::toolTipMouseOverHandler);
  562.             param1.removeEventListener(MouseEvent.MOUSE_OUT,mx_internal::toolTipMouseOutHandler);
  563.             if(mouseIsOver(param1))
  564.             {
  565.                hideImmediately(param1);
  566.             }
  567.          }
  568.       }
  569.       
  570.       private function showImmediately(param1:DisplayObject) : void
  571.       {
  572.          var _loc2_:Number = ToolTipManager.showDelay;
  573.          ToolTipManager.showDelay = 0;
  574.          mx_internal::checkIfTargetChanged(param1);
  575.          ToolTipManager.showDelay = _loc2_;
  576.       }
  577.       
  578.       public function set hideDelay(param1:Number) : void
  579.       {
  580.          _hideDelay = param1;
  581.       }
  582.       
  583.       private function getSystemManager(param1:DisplayObject) : ISystemManager
  584.       {
  585.          return param1 is IUIComponent ? IUIComponent(param1).systemManager : null;
  586.       }
  587.       
  588.       public function set currentTarget(param1:DisplayObject) : void
  589.       {
  590.          _currentTarget = param1;
  591.       }
  592.       
  593.       public function sizeTip(param1:IToolTip) : void
  594.       {
  595.          if(param1 is IInvalidating)
  596.          {
  597.             IInvalidating(param1).validateNow();
  598.          }
  599.          param1.setActualSize(param1.getExplicitOrMeasuredWidth(),param1.getExplicitOrMeasuredHeight());
  600.       }
  601.       
  602.       public function set showEffect(param1:IAbstractEffect) : void
  603.       {
  604.          _showEffect = param1 as IAbstractEffect;
  605.       }
  606.       
  607.       mx_internal function targetChanged() : void
  608.       {
  609.          var _loc1_:ToolTipEvent = null;
  610.          var _loc2_:InterManagerRequest = null;
  611.          if(!mx_internal::initialized)
  612.          {
  613.             mx_internal::initialize();
  614.          }
  615.          if(Boolean(mx_internal::previousTarget) && Boolean(currentToolTip))
  616.          {
  617.             if(currentToolTip is IToolTip)
  618.             {
  619.                _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_HIDE);
  620.                _loc1_.toolTip = currentToolTip;
  621.                mx_internal::previousTarget.dispatchEvent(_loc1_);
  622.             }
  623.             else
  624.             {
  625.                _loc2_ = new InterManagerRequest(InterManagerRequest.TOOLTIP_MANAGER_REQUEST);
  626.                _loc2_.name = ToolTipEvent.TOOL_TIP_HIDE;
  627.                sandboxRoot.dispatchEvent(_loc2_);
  628.             }
  629.          }
  630.          mx_internal::reset();
  631.          if(currentTarget)
  632.          {
  633.             if(mx_internal::currentText == "")
  634.             {
  635.                return;
  636.             }
  637.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_START);
  638.             currentTarget.dispatchEvent(_loc1_);
  639.             if(showDelay == 0 || mx_internal::scrubTimer.running)
  640.             {
  641.                mx_internal::createTip();
  642.                mx_internal::initializeTip();
  643.                mx_internal::positionTip();
  644.                mx_internal::showTip();
  645.             }
  646.             else
  647.             {
  648.                mx_internal::showTimer.delay = showDelay;
  649.                mx_internal::showTimer.start();
  650.             }
  651.          }
  652.       }
  653.       
  654.       public function set hideEffect(param1:IAbstractEffect) : void
  655.       {
  656.          _hideEffect = param1 as IAbstractEffect;
  657.       }
  658.       
  659.       mx_internal function hideTimer_timerHandler(param1:TimerEvent) : void
  660.       {
  661.          mx_internal::hideTip();
  662.       }
  663.       
  664.       mx_internal function initializeTip() : void
  665.       {
  666.          if(currentToolTip is IToolTip)
  667.          {
  668.             IToolTip(currentToolTip).text = mx_internal::currentText;
  669.          }
  670.          if(mx_internal::isError && currentToolTip is IStyleClient)
  671.          {
  672.             IStyleClient(currentToolTip).setStyle("styleName","errorTip");
  673.          }
  674.          sizeTip(currentToolTip);
  675.          if(currentToolTip is IStyleClient)
  676.          {
  677.             if(showEffect)
  678.             {
  679.                IStyleClient(currentToolTip).setStyle("showEffect",showEffect);
  680.             }
  681.             if(hideEffect)
  682.             {
  683.                IStyleClient(currentToolTip).setStyle("hideEffect",hideEffect);
  684.             }
  685.          }
  686.          if(Boolean(showEffect) || Boolean(hideEffect))
  687.          {
  688.             currentToolTip.addEventListener(EffectEvent.EFFECT_END,mx_internal::effectEndHandler);
  689.          }
  690.       }
  691.       
  692.       public function get showEffect() : IAbstractEffect
  693.       {
  694.          return _showEffect;
  695.       }
  696.       
  697.       mx_internal function toolTipMouseOverHandler(param1:MouseEvent) : void
  698.       {
  699.          mx_internal::checkIfTargetChanged(DisplayObject(param1.target));
  700.       }
  701.       
  702.       mx_internal function hideTip() : void
  703.       {
  704.          var _loc1_:ToolTipEvent = null;
  705.          var _loc2_:ISystemManager = null;
  706.          if(mx_internal::previousTarget)
  707.          {
  708.             _loc1_ = new ToolTipEvent(ToolTipEvent.TOOL_TIP_HIDE);
  709.             _loc1_.toolTip = currentToolTip;
  710.             mx_internal::previousTarget.dispatchEvent(_loc1_);
  711.          }
  712.          if(currentToolTip)
  713.          {
  714.             currentToolTip.visible = false;
  715.          }
  716.          if(mx_internal::isError)
  717.          {
  718.             if(currentTarget)
  719.             {
  720.                currentTarget.removeEventListener("change",mx_internal::changeHandler);
  721.             }
  722.          }
  723.          else if(mx_internal::previousTarget)
  724.          {
  725.             _loc2_ = getSystemManager(mx_internal::previousTarget);
  726.             _loc2_.removeEventListener(MouseEvent.MOUSE_DOWN,mx_internal::systemManager_mouseDownHandler);
  727.          }
  728.          if(!hideEffect)
  729.          {
  730.             mx_internal::hideEffectEnded();
  731.          }
  732.       }
  733.       
  734.       mx_internal function createTip() : void
  735.       {
  736.          var _loc1_:ToolTipEvent = new ToolTipEvent(ToolTipEvent.TOOL_TIP_CREATE);
  737.          currentTarget.dispatchEvent(_loc1_);
  738.          if(_loc1_.toolTip)
  739.          {
  740.             currentToolTip = _loc1_.toolTip;
  741.          }
  742.          else
  743.          {
  744.             currentToolTip = new toolTipClass();
  745.          }
  746.          currentToolTip.visible = false;
  747.          var _loc2_:ISystemManager = getSystemManager(currentTarget) as ISystemManager;
  748.          _loc2_.topLevelSystemManager.addChildToSandboxRoot("toolTipChildren",currentToolTip as DisplayObject);
  749.       }
  750.    }
  751. }
  752.  
  753.